

#import <sys/socket.h>
#import <netinet/in.h>
#import <netinet6/in6.h>
#import <arpa/inet.h>
#import <ifaddrs.h>
#import <netdb.h>

#import <CoreFoundation/CoreFoundation.h>

#import "CustomReachability.h"

#define kShouldPrintReachabilityFlags 0

static void PrintReachabilityFlags(SCNetworkReachabilityFlags    flags, const char* comment)
{
#if kShouldPrintReachabilityFlags
	
    NSLog(@"Reachability Flag Status: %c%c %c%c%c%c%c%c%c %s\n",
			(flags & kSCNetworkReachabilityFlagsIsWWAN)				  ? 'W' : '-',
			(flags & kSCNetworkReachabilityFlagsReachable)            ? 'R' : '-',
			
			(flags & kSCNetworkReachabilityFlagsTransientConnection)  ? 't' : '-',
			(flags & kSCNetworkReachabilityFlagsConnectionRequired)   ? 'c' : '-',
			(flags & kSCNetworkReachabilityFlagsConnectionOnTraffic)  ? 'C' : '-',
			(flags & kSCNetworkReachabilityFlagsInterventionRequired) ? 'i' : '-',
			(flags & kSCNetworkReachabilityFlagsConnectionOnDemand)   ? 'D' : '-',
			(flags & kSCNetworkReachabilityFlagsIsLocalAddress)       ? 'l' : '-',
			(flags & kSCNetworkReachabilityFlagsIsDirect)             ? 'd' : '-',
			comment
			);
	 
#endif
}


@implementation CustomReachability

@synthesize internetReachable, hostReachable, delegate, isInBGThread, reachType;

static void ReachabilityCallback(SCNetworkReachabilityRef target, SCNetworkReachabilityFlags flags, void* info)
{
	#pragma unused (target, flags)
	NSCAssert(info != NULL, @"info was NULL in ReachabilityCallback");
	NSCAssert([(NSObject*) info isKindOfClass: [CustomReachability class]], @"info was wrong class in ReachabilityCallback");

	//We're on the main RunLoop, so an NSAutoreleasePool is not necessary, but is added defensively
	// in case someon uses the Reachablity object in a different thread.
	NSAutoreleasePool* myPool = [[NSAutoreleasePool alloc] init];
	
	CustomReachability* noteObject = (CustomReachability*) info;
	// Post a notification to notify the client that the network reachability changed.
	[[NSNotificationCenter defaultCenter] postNotificationName: kReachabilityChangedNotification object: noteObject];
	
	[myPool release];
}

- (BOOL) startNotifier
{
	BOOL retVal = NO;
	SCNetworkReachabilityContext	context = {0, self, NULL, NULL, NULL};
	if(SCNetworkReachabilitySetCallback(reachabilityRef, ReachabilityCallback, &context))
	{
		if(SCNetworkReachabilityScheduleWithRunLoop(reachabilityRef, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode))
		{
			retVal = YES;
		}
	}
	return retVal;
}

- (void) stopNotifier
{
	if(reachabilityRef!= NULL)
	{
		SCNetworkReachabilityUnscheduleFromRunLoop(reachabilityRef, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode);
	}
}

- (void) dealloc
{
	//[self stopNotifier];
	if(reachabilityRef!= NULL)
	{
		CFRelease(reachabilityRef);
	}
	[[NSNotificationCenter defaultCenter] removeObserver:self];
	[internetReachable release];
	[hostReachable release];
	
	[super dealloc];
}

+ (CustomReachability*) newReachabilityWithHostName: (NSString*) hostName;
{
	CustomReachability* retVal = NULL;
	SCNetworkReachabilityRef reachability = SCNetworkReachabilityCreateWithName(NULL, [hostName UTF8String]);
	if(reachability!= NULL)
	{
		retVal= [[self alloc] init];
		if(retVal!= NULL)
		{
			retVal->reachabilityRef = reachability;
			retVal->localWiFiRef = NO;
		}
	}
	return retVal;
}

+ (CustomReachability*) newReachabilityWithAddress: (const struct sockaddr_in*) hostAddress;
{
	SCNetworkReachabilityRef reachability = SCNetworkReachabilityCreateWithAddress(kCFAllocatorDefault, (const struct sockaddr*)hostAddress);
	CustomReachability* retVal = NULL;
	if(reachability!= NULL)
	{
		retVal= [[self alloc] init];
		if(retVal!= NULL)
		{
			retVal->reachabilityRef = reachability;
			retVal->localWiFiRef = NO;
		}
	}
	return retVal;
}

+ (CustomReachability*) newReachabilityForInternetConnection;
{
	struct sockaddr_in zeroAddress;
	bzero(&zeroAddress, sizeof(zeroAddress));
	zeroAddress.sin_len = sizeof(zeroAddress);
	zeroAddress.sin_family = AF_INET;
	return [self newReachabilityWithAddress: &zeroAddress];
}

+ (CustomReachability*) newReachabilityForLocalWiFi;
{
	struct sockaddr_in localWifiAddress;
	bzero(&localWifiAddress, sizeof(localWifiAddress));
	localWifiAddress.sin_len = sizeof(localWifiAddress);
	localWifiAddress.sin_family = AF_INET;
	// IN_LINKLOCALNETNUM is defined in <netinet/in.h> as 169.254.0.0
	localWifiAddress.sin_addr.s_addr = htonl(IN_LINKLOCALNETNUM);
	CustomReachability* retVal = [self newReachabilityWithAddress: &localWifiAddress];
	if(retVal!= NULL)
	{
		retVal->localWiFiRef = YES;
	}
	return retVal;
}

#pragma mark Network Flag Handling

- (NetworkStatus) localWiFiStatusForFlags: (SCNetworkReachabilityFlags) flags
{
	PrintReachabilityFlags(flags, "localWiFiStatusForFlags");

	BOOL retVal = NotReachable;
	if((flags & kSCNetworkReachabilityFlagsReachable) && (flags & kSCNetworkReachabilityFlagsIsDirect))
	{
		retVal = ReachableViaWiFi;	
	}
	return retVal;
}

- (NetworkStatus) networkStatusForFlags: (SCNetworkReachabilityFlags) flags
{
	PrintReachabilityFlags(flags, "networkStatusForFlags");
	if ((flags & kSCNetworkReachabilityFlagsReachable) == 0)
	{
		// if target host is not reachable
		return NotReachable;
	}

	BOOL retVal = NotReachable;
	
	if ((flags & kSCNetworkReachabilityFlagsConnectionRequired) == 0)
	{
		// if target host is reachable and no connection is required
		//  then we'll assume (for now) that your on Wi-Fi
		retVal = ReachableViaWiFi;
	}
	
	
	if ((((flags & kSCNetworkReachabilityFlagsConnectionOnDemand ) != 0) ||
		(flags & kSCNetworkReachabilityFlagsConnectionOnTraffic) != 0))
	{
			// ... and the connection is on-demand (or on-traffic) if the
			//     calling application is using the CFSocketStream or higher APIs

			if ((flags & kSCNetworkReachabilityFlagsInterventionRequired) == 0)
			{
				// ... and no [user] intervention is needed
				retVal = ReachableViaWiFi;
			}
		}
	
	if ((flags & kSCNetworkReachabilityFlagsIsWWAN) == kSCNetworkReachabilityFlagsIsWWAN)
	{
		// ... but WWAN connections are OK if the calling application
		//     is using the CFNetwork (CFSocketStream?) APIs.
		retVal = ReachableViaWWAN;
	}
	return retVal;
}

- (BOOL) connectionRequired;
{
	NSAssert(reachabilityRef != NULL, @"connectionRequired called with NULL reachabilityRef");
	SCNetworkReachabilityFlags flags;
	if (SCNetworkReachabilityGetFlags(reachabilityRef, &flags))
	{
		return (flags & kSCNetworkReachabilityFlagsConnectionRequired);
	}
	return NO;
}

- (NetworkStatus) currentReachabilityStatus
{
	NSAssert(reachabilityRef != NULL, @"currentNetworkStatus called with NULL reachabilityRef");
	NetworkStatus retVal = NotReachable;
	SCNetworkReachabilityFlags flags;
	if (SCNetworkReachabilityGetFlags(reachabilityRef, &flags))
	{
		if(localWiFiRef)
		{
			retVal = [self localWiFiStatusForFlags: flags];
		}
		else
		{
			retVal = [self networkStatusForFlags: flags];
		}
	}
	return retVal;
}

#pragma mark -
#pragma mark Custom methods

- (void) startCheckInternetConnectionAndNotifyDelegate {
	[[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(checkNetworkStatus:) name:kReachabilityChangedNotification object:nil];
	CustomReachability *cr = [CustomReachability newReachabilityForInternetConnection];
	self.internetReachable = cr;
	[cr release];
	[self checkNetworkStatus:nil];
	[internetReachable startNotifier];
}

- (void) checkInternetConnection {
    if (isInBGThread) {
        [NSThread detachNewThreadSelector:@selector(checkInternetConnectionInBGThread) toTarget:self withObject:nil];
    } else {
		CustomReachability *cr = [CustomReachability newReachabilityForInternetConnection];
        self.internetReachable = cr;
		[cr release];
        [self checkNetworkStatus:nil];
    }
    
}

- (void) checkInternetConnectionInBGThread {
    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
	CustomReachability *cr = [CustomReachability newReachabilityForInternetConnection];
	self.internetReachable = cr;
	[cr release];
    [self checkNetworkStatus:nil];
    [pool release];
}

- (void) checkHost:(NSString*)hostName {
    if (isInBGThread) {
        [NSThread detachNewThreadSelector:@selector(checkHostInBGThread:) toTarget:self withObject:hostName];
    } else {
		CustomReachability *cr = [CustomReachability newReachabilityWithHostName:hostName];
        self.hostReachable = cr;
		[cr release];
		
        [self checkHostName:nil];
    }
    
	
}

- (void) checkHostInBGThread:(NSString*)hostName {
    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
	CustomReachability *cr = [CustomReachability newReachabilityWithHostName:hostName];
	self.hostReachable = cr;
	[cr release];
	[self checkHostName:nil];
    [pool release];
}

- (void) checkNetworkStatus:(NSNotification *)notice {
	// called after network status changes
	
	NetworkStatus internetStatus = [internetReachable currentReachabilityStatus];
	switch (internetStatus) {
		case NotReachable:
		{
			
			//self.internetActive = NO;
            if (isInBGThread) {
                
                [self.delegate performSelectorOnMainThread:@selector(connectionOff:) withObject:self waitUntilDone:NO];
            } else {
                [self.delegate connectionOff:self];
                
            }
			break;
			
		}
		case ReachableViaWiFi:
		{
			
			//self.internetActive = YES;
            if (isInBGThread) {
                
                [self.delegate performSelectorOnMainThread:@selector(connectionOn:) withObject:self waitUntilDone:NO];
                if ([((NSObject*)self.delegate) respondsToSelector:@selector(connectionOnViaWIFI:)]) {
                    [self.delegate performSelectorOnMainThread:@selector(connectionOnViaWIFI:) withObject:self waitUntilDone:NO];
                }
            } else {
                [self.delegate connectionOn:self];
                if ([((NSObject*)self.delegate) respondsToSelector:@selector(connectionOnViaWIFI:)]) {
                    [self.delegate connectionOnViaWIFI:self];
                }
            }
             
			
			break;
			
		}
		case ReachableViaWWAN:
		{
			
			//self.internetActive = YES;
            
            if (isInBGThread) {
                
                [self.delegate performSelectorOnMainThread:@selector(connectionOn:) withObject:self waitUntilDone:NO];
                if ([((NSObject*)self.delegate) respondsToSelector:@selector(connectionONViaWWAN:)]) {
                    [self.delegate performSelectorOnMainThread:@selector(connectionONViaWWAN:) withObject:self waitUntilDone:NO];
                }
            } else {
                [self.delegate connectionOn:self];
                if ([((NSObject*)self.delegate) respondsToSelector:@selector(connectionONViaWWAN:)]) {
                    [self.delegate connectionONViaWWAN:self];
                }
            }
            
			break;
			
		}
	}
	
}

- (void) checkHostName:(NSNotification *)notice {
    NetworkStatus hostStatus = [hostReachable currentReachabilityStatus];
	switch (hostStatus)
	
	{
		case NotReachable:
		{
			
			//self.hostActive = NO;
            if (isInBGThread) {
                
                if ([((NSObject*)self.delegate) respondsToSelector:@selector(hostNotReachable:)]) {
                    [self.delegate performSelectorOnMainThread:@selector(hostNotReachable:) withObject:self waitUntilDone:NO];
                }
            } else {
                if ([((NSObject*)self.delegate) respondsToSelector:@selector(hostNotReachable:)]) {
                    [self.delegate hostNotReachable:self];
                }
            }
            
            
			
			break;
			
		}
		case ReachableViaWiFi:
		{
			
			//self.hostActive = YES;
            if (isInBGThread) {
               
                if ([((NSObject*)self.delegate) respondsToSelector:@selector(hostReachable:)]) {
                    [self.delegate performSelectorOnMainThread:@selector(hostReachable:) withObject:self waitUntilDone:NO];
                }
                if ([((NSObject*)self.delegate) respondsToSelector:@selector(hostReachableViaWIFI:)]) {
                    [self.delegate performSelectorOnMainThread:@selector(hostReachableViaWIFI:) withObject:self waitUntilDone:NO];
                }
            } else {
                if ([((NSObject*)self.delegate) respondsToSelector:@selector(hostReachable:)]) {
                    [self.delegate hostReachable:self];
                }
                if ([((NSObject*)self.delegate) respondsToSelector:@selector(hostReachableViaWIFI:)]) {
                    [self.delegate hostReachableViaWIFI:self];
                }
            }
            
            
            
			
			break;
			
		}
		case ReachableViaWWAN:
		{
			
			//self.hostActive = YES;
            if (isInBGThread) {
                
                if ([((NSObject*)self.delegate) respondsToSelector:@selector(hostReachable:)]) {
                    [self.delegate performSelectorOnMainThread:@selector(hostReachable:) withObject:self waitUntilDone:NO];
                }
                if ([((NSObject*)self.delegate) respondsToSelector:@selector(hostReachableViaWWAN:)]) {
                    [self.delegate performSelectorOnMainThread:@selector(hostReachableViaWWAN) withObject:self waitUntilDone:NO];
                }
            } else {
                if ([((NSObject*)self.delegate) respondsToSelector:@selector(hostReachable:)]) {
                    [self.delegate hostReachable:self];
                }
                if ([((NSObject*)self.delegate) respondsToSelector:@selector(hostReachableViaWWAN:)]) {
                    [self.delegate hostReachableViaWWAN:self];
                }
            }
            
            
			
			break;
			
		}
	}
}

//Reachability in bg thread:







@end
